package platzerworld.kegeln.gui.wettkampf;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import platzerworld.kegeln.R;
import platzerworld.kegeln.common.ConstantsIF;
import platzerworld.kegeln.common.KeyValueVO;
import platzerworld.kegeln.common.logging.LOG;
import platzerworld.kegeln.common.pdf.PDFWriter;
import platzerworld.kegeln.common.pdf.PaperSize;
import platzerworld.kegeln.common.preference.KegelverwaltungPreference;
import platzerworld.kegeln.common.style.StyleManager;
import platzerworld.kegeln.db.ergebnis.ErgebnisSpeicher;
import platzerworld.kegeln.db.klasse.KlasseSpeicher;
import platzerworld.kegeln.db.mannschaft.MannschaftSpeicher;
import platzerworld.kegeln.db.spieler.SpielerSpeicher;
import platzerworld.kegeln.db.wettkampf.WettkampfSpeicher;
import platzerworld.kegeln.gui.tabs.PaarungTabActivity;
import platzerworld.kegeln.vo.ergebnis.ErgebnisVO;
import platzerworld.kegeln.vo.klasse.KlasseVO;
import platzerworld.kegeln.vo.mannschaft.MannschaftVO;
import platzerworld.kegeln.vo.spieler.SpielerVO;
import platzerworld.kegeln.vo.wettkampf.WettkampfVO;
import android.app.Activity;
import android.app.DatePickerDialog;
import android.app.Dialog;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.Typeface;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnTouchListener;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

/**
 * Durchf�hrung eines Spiels in der Kegelkreisrunde Ebersberg-Erding.
 * 
 * @author platzerg
 * 
 */
public class Wettkampf extends Activity implements ConstantsIF {
	private static final long serialVersionUID = -5920434564538725124L;
	private static final String TAG = Wettkampf.class.getSimpleName();
	
	private KlasseSpeicher mKlasseSpeicher;
	private MannschaftSpeicher mMannschaftSpeicher;
	private WettkampfSpeicher mWettkampfSpeicher;
	private ErgebnisSpeicher mErgebnisSpeicher;
	private SpielerSpeicher mSpielerSpeicher;
	
	private Map<Integer, ErgebnisVO[]> paarungen = new HashMap<Integer, ErgebnisVO[]>();

	static Spinner mSpielgruppeSpinner = null;
	static Spinner mMannschaftHeimSpinner = null;
	static Spinner mMannschaftGastSpinner = null;

	public int mYear;
	public int mMonth;
	public int mDay;
	
	private EditText edtSpielTag;
	private EditText edtSpielNr;
	
	private Button mPaarung1Button;
	private Button mPaarung2Button;
	private Button mPaarung3Button;
	private Button mPaarung4Button;
	private Button mPaarung5Button;
	private Button mPaarung6Button;
	
	private EditText mEdtPaarung1;
	private EditText mEdtPaarung2;
	private EditText mEdtPaarung3;
	private EditText mEdtPaarung4;
	private EditText mEdtPaarung5;
	private EditText mEdtPaarung6;
	
	private Button mButtonLadeWettkamfp = null;
	private Button mButtonEndergebnis = null;
	
	private WettkampfVO wettkampfVO = null;
	
	
	private int mSelectedKlasseItemPosition=0;
	private int mSelectedMannschaftHeimItemPosition=0;
	private int mSelectedMannschaftGastItemPosition=0;
	
	private KeyValueVO mSelectedMannschaftHeimKeyValueVO = null;
	private KeyValueVO mSelectedMannschaftGastKeyValueVO = null;
	private KeyValueVO mSelectedKlasseKeyValueVO = null;
	
	private ErgebnisVO mSelectedErgebnisHeimVO = null;
	private ErgebnisVO mSelectedErgebnisGastVO = null;
	
	private int mPaarungInex=0;
	
	private long mWettkampfSpielNr=0;
	
	private boolean update=false;
	
	@Override
	protected void onCreate(Bundle icicle) {
		super.onCreate(icicle);
		LOG.v(TAG, "onCreate(): entered...");
		
		setContentView(R.layout.spielbetrieb);
		setTitle(R.string.txt_wettkampf_titel);
		
		init();
	}
	
	@Override
	protected void onStart() {
		super.onStart();
	}
	
	@Override
	protected void onResume() {
		loadPreference();
		mSpielgruppeSpinner.setSelection(mSelectedKlasseItemPosition);
		mMannschaftHeimSpinner.setSelection(mSelectedMannschaftHeimItemPosition, true);
		mMannschaftGastSpinner.setSelection(mSelectedMannschaftGastItemPosition, true);
		super.onResume();
	}

	@Override
	protected void onPause() {
		savePreference();
		LOG.v(TAG, "onPause(): entered...");
		super.onPause();
	}

	@Override
	protected void onRestart() {
		super.onRestart();
	}

	@Override
	protected void onStop() {
		super.onStop();
	}

	@Override
	protected void onDestroy() {
		cleanDatabase();
		super.onDestroy();
	}
	
	@Override
	protected Dialog onCreateDialog(int id) {
	   switch (id) {
	   case DATE_DIALOG_ID:
	      return new DatePickerDialog(this, mDateSetListener, mYear, mMonth, mDay);
	   }
	   return null;
	}
	

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		getMenuInflater().inflate(R.menu.wettkampf_option_menu, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		return applyMenuChoice(item);
	}

	private boolean applyMenuChoice(MenuItem item) {
		switch (item.getItemId()) {
		case R.id.opt_wettkampf_email:
			wettkampfEMail();
			return true;
		case R.id.opt_wettkampf_email_mit_anhang:
			wettkampfEMailMitAnhang();
			return true;
		case R.id.opt_wettkampf_erzeuge_pdf:
			wettkampfPDF();
			return true;
		default:
			return super.onOptionsItemSelected(item);
		}
	}

	private DatePickerDialog.OnDateSetListener mDateSetListener =
	    new DatePickerDialog.OnDateSetListener() {
	        public void onDateSet(DatePicker view, int year,  int monthOfYear, int dayOfMonth) {
	            mYear = year; mMonth = monthOfYear; mDay = dayOfMonth;
	            updateDisplay();
	        }
	};
	
    private void updateDisplay() {
	    edtSpielTag.setText( new StringBuilder().append(mDay).append(".").append(mMonth + 1).append(".").append(mYear));
	}
	
	private void init(){
		initStyle();
		initWidgets();
		initListener();
		initContextMenu();
		initDatabase();
		
		zeigeKlassen();
	}
	
	private void initStyle() {
		Typeface font = StyleManager.getInstance().init(this).getTypeface();
		TextView titeltext = (TextView) findViewById(R.id.txt_wettkampf_titel);
		titeltext.setTypeface(font);
		
	}
	
	private void initWidgets(){
		mSpielgruppeSpinner = (Spinner) this.findViewById(R.id.sp_spielbetrieb_spielgruppe);
		mMannschaftHeimSpinner = (Spinner) this.findViewById(R.id.sp_spielbetrieb_heim_club);
		mMannschaftGastSpinner = (Spinner) this.findViewById(R.id.sp_spielbetrieb_gast_club);
		mButtonLadeWettkamfp = (Button) findViewById(R.id.sf_spielbetrieb_lade_Wettkampf);
		mButtonEndergebnis = (Button) findViewById(R.id.sf_spielbetrieb_zeige_endergebnis);
		
		mPaarung1Button = (Button) findViewById(R.id.sf_spielbetrieb_paarung_1);
		mPaarung2Button = (Button) findViewById(R.id.sf_spielbetrieb_paarung_2);
		mPaarung3Button = (Button) findViewById(R.id.sf_spielbetrieb_paarung_3);
		mPaarung4Button = (Button) findViewById(R.id.sf_spielbetrieb_paarung_4);
		mPaarung5Button = (Button) findViewById(R.id.sf_spielbetrieb_paarung_5);
		mPaarung6Button = (Button) findViewById(R.id.sf_spielbetrieb_paarung_6);
		
		mEdtPaarung1 = (EditText) findViewById(R.id.edt_spielbetrieb_paarung_1);
		mEdtPaarung2 = (EditText) findViewById(R.id.edt_spielbetrieb_paarung_2);
		mEdtPaarung3 = (EditText) findViewById(R.id.edt_spielbetrieb_paarung_3);
		mEdtPaarung4 = (EditText) findViewById(R.id.edt_spielbetrieb_paarung_4);
		mEdtPaarung5 = (EditText) findViewById(R.id.edt_spielbetrieb_paarung_5);
		mEdtPaarung6 = (EditText) findViewById(R.id.edt_spielbetrieb_paarung_6);
		
		edtSpielTag = (EditText) findViewById(R.id.edt_spielbetrieb_spieltag);
		edtSpielNr = (EditText) findViewById(R.id.edt_spielbetrieb_spielnr);
	}
	
	private void initListener(){
		mSpielgruppeSpinner.setOnItemSelectedListener(mSpinnerKlassenItemAuswahlListener);
		mMannschaftHeimSpinner.setOnItemSelectedListener(mSpinnerMannschaftenHeimItemAuswahlListener);
		mMannschaftGastSpinner.setOnItemSelectedListener(mSpinnerMannschaftenGastItemAuswahlListener);
		
		edtSpielTag.setOnTouchListener(mSpielTagListener);
		
		mButtonLadeWettkamfp.setOnClickListener(mLadeWettkampfListener);
		mButtonEndergebnis.setOnClickListener(mEndergebnisListener);
		
		mPaarung1Button.setOnClickListener(mPaarung1OnOkListener);
		mPaarung2Button.setOnClickListener(mPaarung2OnOkListener);
		mPaarung3Button.setOnClickListener(mPaarung3OnOkListener);
		mPaarung4Button.setOnClickListener(mPaarung4OnOkListener);
		mPaarung5Button.setOnClickListener(mPaarung5OnOkListener);
		mPaarung6Button.setOnClickListener(mPaarung6OnOkListener);
	}
	
	private void initContextMenu(){
	}
	
	private void initDatabase(){
		mKlasseSpeicher = new KlasseSpeicher(this);
		mWettkampfSpeicher = new WettkampfSpeicher(this);
		mErgebnisSpeicher = new ErgebnisSpeicher(this);
		
		final Calendar c = Calendar.getInstance();
		mYear = c.get(Calendar.YEAR);
	    mMonth = c.get(Calendar.MONTH);
	    mDay = c.get(Calendar.DAY_OF_MONTH);
	}
	
	private void cleanDatabase(){
		if(null != mKlasseSpeicher){
			mKlasseSpeicher.schliessen();
		}
		if(null != mMannschaftSpeicher){
			mMannschaftSpeicher.schliessen();
		}
		if(null != mWettkampfSpeicher){
			mWettkampfSpeicher.schliessen();
		}
		if(null != mErgebnisSpeicher){
			mErgebnisSpeicher.schliessen();
		}
		if(null != mSpielerSpeicher){
			mSpielerSpeicher.schliessen();
		}
	}
	
	
	private void zeigeKlassen() {
		List<KlasseVO> klassenListeVO = mKlasseSpeicher.ladeAlleKlassenListeVO();

		ArrayAdapter<KlasseVO> klassenAdapter = new ArrayAdapter<KlasseVO>(
				this, android.R.layout.simple_spinner_item, klassenListeVO);

		mSpielgruppeSpinner.setAdapter(klassenAdapter);
		klassenAdapter.setDropDownViewResource(android.R.layout.simple_spinner_item);

	}

	private void zeigeMannschaftenZurKlasseId(long klasseId) {
		List<MannschaftVO> mannschaftenListeVO = mMannschaftSpeicher.ladeAlleMannschaftListeVO(klasseId);

		ArrayAdapter<MannschaftVO> mannschaftenAdapter = new ArrayAdapter<MannschaftVO>(this,
				android.R.layout.simple_spinner_item, mannschaftenListeVO);

		mannschaftenAdapter.setDropDownViewResource(android.R.layout.simple_spinner_item);

		mMannschaftHeimSpinner.setAdapter(mannschaftenAdapter);
		mMannschaftGastSpinner.setAdapter(mannschaftenAdapter);
		

	}

	private final AdapterView.OnItemSelectedListener mSpinnerKlassenItemAuswahlListener = new AdapterView.OnItemSelectedListener() {
		public void onItemSelected(AdapterView<?> arg0, View arg1, int position, long id) {
			mSelectedKlasseItemPosition = position;
			
			KeyValueVO keyValueVO = (KeyValueVO) mSpielgruppeSpinner.getSelectedItem();
			mSelectedKlasseKeyValueVO = keyValueVO;
			
			mMannschaftSpeicher = new MannschaftSpeicher(Wettkampf.this);
			zeigeMannschaftenZurKlasseId(keyValueVO.key);
			if(mSelectedMannschaftHeimItemPosition <= mMannschaftHeimSpinner.getAdapter().getCount()){
				mMannschaftHeimSpinner.setSelection(mSelectedMannschaftHeimItemPosition);
			}else{
				mMannschaftHeimSpinner.setSelection(0);
			}
			
			if(mSelectedMannschaftGastItemPosition <= mMannschaftGastSpinner.getAdapter().getCount()){
				mMannschaftGastSpinner.setSelection(mSelectedMannschaftGastItemPosition);
			}else{
				mMannschaftGastSpinner.setSelection(0);
			}
		}

		public void onNothingSelected(AdapterView<?> arg0) {
		}
	};

	private final AdapterView.OnItemSelectedListener mSpinnerMannschaftenHeimItemAuswahlListener = new AdapterView.OnItemSelectedListener() {
		public void onItemSelected(AdapterView<?> arg0, View arg1, int position, long id) {
			mSelectedMannschaftHeimItemPosition = position;
			KeyValueVO keyValueVO = (KeyValueVO) mMannschaftHeimSpinner.getSelectedItem();
			mSelectedMannschaftHeimKeyValueVO = keyValueVO;
		}

		public void onNothingSelected(AdapterView<?> arg0) {
		}
	};
	
	private final AdapterView.OnItemSelectedListener mSpinnerMannschaftenGastItemAuswahlListener = new AdapterView.OnItemSelectedListener() {
		public void onItemSelected(AdapterView<?> arg0, View arg1, int position, long id) {
			mSelectedMannschaftGastItemPosition = position;
			KeyValueVO keyValueVO = (KeyValueVO) mMannschaftGastSpinner.getSelectedItem();
			mSelectedMannschaftGastKeyValueVO = keyValueVO;
		}

		public void onNothingSelected(AdapterView<?> arg0) {
		}
	};

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		if (resultCode == RESULT_OK && requestCode == REQUEST_CODE_WETTKAMPF_PAARUNGEN) {
			if (data.hasExtra(INTENT_EXTRA_WETTKAMPF_PAARUNG_HEIM) && data.hasExtra(INTENT_EXTRA_WETTKAMPF_PAARUNG_GAST)) {
				ErgebnisVO[] paarung = new ErgebnisVO[2];
				ErgebnisVO ergHeim = (ErgebnisVO) data.getExtras().getSerializable(INTENT_EXTRA_WETTKAMPF_PAARUNG_HEIM);
				ErgebnisVO ergGast = (ErgebnisVO) data.getExtras().getSerializable(INTENT_EXTRA_WETTKAMPF_PAARUNG_GAST);
				paarung[0] = ergHeim;
				paarung[1] = ergGast;
				paarungen.put(new Integer(mPaarungInex), paarung);
				updatePaarungErgebnisse();
			}
		} 
	}
	
	private void updatePaarungErgebnisse(){
		mEdtPaarung1.setText("0 - 0");
		mEdtPaarung2.setText("0 - 0");
		mEdtPaarung3.setText("0 - 0");
		mEdtPaarung4.setText("0 - 0");
		mEdtPaarung5.setText("0 - 0");
		mEdtPaarung6.setText("0 - 0");
		if(paarungen.containsKey(new Integer(1))){
			mEdtPaarung1.setText(getErgebnisProPaarung(paarungen.get(new Integer(1))));
		}
		if(paarungen.containsKey(new Integer(2))){
			mEdtPaarung2.setText(getErgebnisProPaarung(paarungen.get(new Integer(2))));		
		}
		if(paarungen.containsKey(new Integer(3))){
			mEdtPaarung3.setText(getErgebnisProPaarung(paarungen.get(new Integer(3))));
		}
		if(paarungen.containsKey(new Integer(4))){
			mEdtPaarung4.setText(getErgebnisProPaarung(paarungen.get(new Integer(4))));
		}
		if(paarungen.containsKey(new Integer(5))){
			mEdtPaarung5.setText(getErgebnisProPaarung(paarungen.get(new Integer(5))));
		}
		if(paarungen.containsKey(new Integer(6))){
			mEdtPaarung6.setText(getErgebnisProPaarung(paarungen.get(new Integer(6))));
		}
	}
	
	private long errechneGesamtErgebnis(boolean isHeim){
		long erg = 0;
		int pos = isHeim ? 0 : 1;
		ErgebnisVO [] ergebnisse = null;
		if(paarungen.containsKey(new Integer(1))){
			ergebnisse = paarungen.get(new Integer(1));
			erg += ergebnisse[pos].gesamtergebnis;
		}
		if(paarungen.containsKey(new Integer(2))){
			ergebnisse = paarungen.get(new Integer(2));
			erg += ergebnisse[pos].gesamtergebnis;
		}
		if(paarungen.containsKey(new Integer(3))){
			ergebnisse = paarungen.get(new Integer(3));
			erg += ergebnisse[pos].gesamtergebnis;
		}
		if(paarungen.containsKey(new Integer(4))){
			ergebnisse = paarungen.get(new Integer(4));
			erg += ergebnisse[pos].gesamtergebnis;
		}
		if(paarungen.containsKey(new Integer(5))){
			ergebnisse = paarungen.get(new Integer(5));
			erg += ergebnisse[pos].gesamtergebnis;
		}
		if(paarungen.containsKey(new Integer(6))){
			ergebnisse = paarungen.get(new Integer(6));
			erg += ergebnisse[pos].gesamtergebnis;
		}
		return erg;
	}
	
	private String getErgebnisProPaarung(ErgebnisVO[] paarung){
		StringBuffer bf = new StringBuffer();
		if( null != paarung[0] && null != paarung[1] ){
			bf.append(paarung[0].gesamtergebnis).append(" - ").append(paarung[1].gesamtergebnis);
		}else{
			return "0 - 0";
		}
		
		
		return bf.toString();
	}
	
	private final OnTouchListener mSpielTagListener = new OnTouchListener() {
		
		@Override
		public boolean onTouch(View v, MotionEvent event) {
			if(MotionEvent.ACTION_DOWN == event.getAction()){
				showDialog(DATE_DIALOG_ID);
			}
			
			return true;
		}
	};
	
	private final OnClickListener mPaarung1OnOkListener = new OnClickListener() {
		public void onClick(View v) {
			handlePaarung(1);
		}
	};
	
	private final OnClickListener mPaarung2OnOkListener = new OnClickListener() {
		public void onClick(View v) {
			handlePaarung(2);
		}
	};
	
	private final OnClickListener mPaarung3OnOkListener = new OnClickListener() {
		public void onClick(View v) {
			handlePaarung(3);
		}
	};
	
	private final OnClickListener mPaarung4OnOkListener = new OnClickListener() {
		public void onClick(View v) {
			handlePaarung(4);
		}
	};
	
	private final OnClickListener mPaarung5OnOkListener = new OnClickListener() {
		public void onClick(View v) {
			handlePaarung(5);
		}
	};
	
	private final OnClickListener mPaarung6OnOkListener = new OnClickListener() {
		public void onClick(View v) {
			handlePaarung(6);
		}
	};
	
	private void handlePaarung(int paarungIndex) {
		boolean valid = true;
		if(edtSpielTag.getText().length() < 1 ){
			valid = false;
		}
		if(edtSpielNr.getText().length() < 1){
			valid = false;
		}
		
		if(valid){
			final Intent intent = new Intent(this, PaarungTabActivity.class);
			this.mPaarungInex = paarungIndex;
			if(paarungen.containsKey(new Integer(mPaarungInex))){
				ErgebnisVO[] ergebnisse = paarungen.get(new Integer(paarungIndex));
				mSelectedErgebnisHeimVO = ergebnisse[0];
				mSelectedErgebnisGastVO = ergebnisse[1];
			}
			intent.putExtra(INTENT_EXTRA_WETTKAMPF_MANNSCHAFT_HEIM, mSelectedMannschaftHeimKeyValueVO);
			intent.putExtra(INTENT_EXTRA_WETTKAMPF_MANNSCHAFT_GAST, mSelectedMannschaftGastKeyValueVO);
			
			intent.putExtra(INTENT_EXTRA_WETTKAMPF_ERGEBNIS_HEIM, mSelectedErgebnisHeimVO);
			intent.putExtra(INTENT_EXTRA_WETTKAMPF_ERGEBNIS_GAST, mSelectedErgebnisGastVO);
			
			
			intent.putExtra(INTENT_EXTRA_WETTKAMPF_PAARUNG, mPaarungInex);
			intent.putExtra(INTENT_EXTRA_WETTKAMPF_SPIELTAG, edtSpielTag.getText().toString());
			intent.putExtra(INTENT_EXTRA_WETTKAMPF_SPIELNR, edtSpielNr.getText().toString());
			
			intent.putExtra(INTENT_EXTRA_EDIT_MODE, paarungen.containsKey(new Integer(mPaarungInex)));
			
			startActivityForResult(intent, REQUEST_CODE_WETTKAMPF_PAARUNGEN);
		}else{
			Toast.makeText(this, "Spieltag und Spielnummer muessen eingegeben werden!", Toast.LENGTH_LONG).show();
		}
		
	}
	
	private final OnClickListener mEndergebnisListener = new OnClickListener() {
		public void onClick(View v) {
			speichernWettkampf();
		}
	};
	
	private void speichernWettkampf(){
		if(!update){
			wettkampfVO = new WettkampfVO();
		}
		
		
		if(validate()){
			mWettkampfSpielNr = Long.parseLong(edtSpielNr.getText().toString());
			wettkampfVO.spielZeit = edtSpielTag.getText().toString();
			
			wettkampfVO.spielNr = mWettkampfSpielNr;
			wettkampfVO.klasseId = mSelectedKlasseKeyValueVO.key;
			wettkampfVO.heimId = mSelectedMannschaftHeimKeyValueVO.key;
			wettkampfVO.gastId = mSelectedMannschaftGastKeyValueVO.key;
			
			long heimErgebnis = errechneGesamtErgebnis(true);
			long gastErgebnis = errechneGesamtErgebnis(false);
			wettkampfVO.gesamtErgebnis = heimErgebnis + " - " +gastErgebnis;
			
			wettkampfVO.key = mWettkampfSpeicher.speichereWettkampf(wettkampfVO, update);
			
			super.finish();
			
		}
		
	}
	
	private final OnClickListener mLadeWettkampfListener = new OnClickListener() {
		public void onClick(View v) {
			showladeWettkampf();
		}
	};
	
	private void showladeWettkampf(){
		long spielNr = 0;
		if(edtSpielNr.getText().toString().length() >0){
			spielNr = Long.parseLong(edtSpielNr.getText().toString());
			update = true;
			wettkampfVO =  mWettkampfSpeicher.ladeWettkampfVOBySpielNr(spielNr);
			refreshGui();
		}
	}
	
	@SuppressWarnings("unchecked")
	private void refreshGui(){
		if(null != wettkampfVO){
			edtSpielNr.setText(String.valueOf(wettkampfVO.spielNr));
			edtSpielTag.setText(wettkampfVO.spielZeit);
		
			KlasseVO klasseVO = mKlasseSpeicher.ladeKlasse(wettkampfVO.klasseId);
			int posKlasse = ((ArrayAdapter<KlasseVO>)mSpielgruppeSpinner.getAdapter()).getPosition(klasseVO);
			
			mSpielgruppeSpinner.setSelection(posKlasse, true);
			
			MannschaftVO heimVO = mMannschaftSpeicher.ladeMannschaftVO(wettkampfVO.heimId);
			int posHeim = ((ArrayAdapter<MannschaftVO>)mMannschaftHeimSpinner.getAdapter()).getPosition(heimVO);
			mMannschaftHeimSpinner.setSelection(posHeim, true);
			
			MannschaftVO gastVO = mMannschaftSpeicher.ladeMannschaftVO(wettkampfVO.gastId);
			int posGast = ((ArrayAdapter<MannschaftVO>)mMannschaftGastSpinner.getAdapter()).getPosition(gastVO);
			mMannschaftGastSpinner.setSelection(posGast, true);

			ErgebnisVO[] paarung = new ErgebnisVO[2];
			ErgebnisVO ergHeim = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung1ErgebnisHeim);
			ErgebnisVO ergGast = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung1ErgebnisGast);
			paarung[0] = ergHeim;
			paarung[1] = ergGast;
			if(null != ergHeim && null != ergGast){
				paarungen.put(new Integer(1), paarung);
			}
			
			paarung = new ErgebnisVO[2];
			ergHeim = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung2ErgebnisHeim);
			ergGast = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung2ErgebnisGast);
			paarung[0] = ergHeim;
			paarung[1] = ergGast;
			if(null != ergHeim && null != ergGast){
				paarungen.put(new Integer(2), paarung);
			}
			
			paarung = new ErgebnisVO[2];
			ergHeim = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung3ErgebnisHeim);
			ergGast = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung3ErgebnisGast);
			paarung[0] = ergHeim;
			paarung[1] = ergGast;
			if(null != ergHeim && null != ergGast){
				paarungen.put(new Integer(3), paarung);
			}
			
			paarung = new ErgebnisVO[2];
			ergHeim = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung4ErgebnisHeim);
			ergGast = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung4ErgebnisGast);
			paarung[0] = ergHeim;
			paarung[1] = ergGast;
			if(null != ergHeim && null != ergGast){
				paarungen.put(new Integer(4), paarung);
			}
			
			paarung = new ErgebnisVO[2];
			ergHeim = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung5ErgebnisHeim);
			ergGast = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung5ErgebnisGast);
			paarung[0] = ergHeim;
			paarung[1] = ergGast;
			if(null != ergHeim && null != ergGast){
				paarungen.put(new Integer(5), paarung);
			}
			
			paarung = new ErgebnisVO[2];
			ergHeim = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung6ErgebnisHeim);
			ergGast = mErgebnisSpeicher.ladeErgebnisVO(wettkampfVO.paarung6ErgebnisGast);
			paarung[0] = ergHeim;
			paarung[1] = ergGast;
			if(null != ergHeim && null != ergGast){
				paarungen.put(new Integer(6), paarung);
			}
			
			updatePaarungErgebnisse();
			
		}
		
	}
	
	private boolean validate(){
		if(edtSpielNr.getText().length() < 1){
			return false;
		}
		if(edtSpielTag.getText().length() < 1){
			edtSpielTag.setText(GregorianCalendar.getInstance().getTime().toGMTString());
		}		
		
		if(paarungen.containsKey(new Integer(1))){
			ErgebnisVO[] p1 = paarungen.get(new Integer(1));
			wettkampfVO.paarung1ErgebnisHeim = p1[0].key;
			wettkampfVO.paarung1ErgebnisGast = p1[1].key;
		}else{
			wettkampfVO.paarung1ErgebnisHeim = 0;
			wettkampfVO.paarung1ErgebnisGast = 0;
		}
		
		if(paarungen.containsKey(new Integer(2))){
			paarungen.get(new Integer(2));
			ErgebnisVO[] p2 = paarungen.get(new Integer(2));
			wettkampfVO.paarung2ErgebnisHeim = p2[0].key;
			wettkampfVO.paarung2ErgebnisGast = p2[1].key;
		} else{
			wettkampfVO.paarung2ErgebnisHeim = 0;
			wettkampfVO.paarung2ErgebnisGast = 0;
		}
		
		if(paarungen.containsKey(new Integer(3))){
			paarungen.get(new Integer(3));
			ErgebnisVO[] p3 = paarungen.get(new Integer(3));
			wettkampfVO.paarung3ErgebnisHeim = p3[0].key;
			wettkampfVO.paarung3ErgebnisGast = p3[1].key;
		}else{
			wettkampfVO.paarung3ErgebnisHeim = 0;
			wettkampfVO.paarung3ErgebnisGast = 0;
		}
		
		if(paarungen.containsKey(new Integer(4))){
			paarungen.get(new Integer(4));
			ErgebnisVO[] p4 = paarungen.get(new Integer(4));
			wettkampfVO.paarung4ErgebnisHeim = p4[0].key;
			wettkampfVO.paarung4ErgebnisGast = p4[1].key;
		}else{
			wettkampfVO.paarung4ErgebnisHeim = 0;
			wettkampfVO.paarung4ErgebnisGast = 0;
		}
			
		if(paarungen.containsKey(new Integer(5))){
			paarungen.get(new Integer(5));
			ErgebnisVO[] p5 = paarungen.get(new Integer(5));
			wettkampfVO.paarung5ErgebnisHeim = p5[0].key;
			wettkampfVO.paarung5ErgebnisGast = p5[1].key;
		}else{
			wettkampfVO.paarung5ErgebnisHeim = 0;
			wettkampfVO.paarung5ErgebnisGast = 0;
		}
		
		if(paarungen.containsKey(new Integer(6))){
			paarungen.get(new Integer(6));
			ErgebnisVO[] p6 = paarungen.get(new Integer(6));
			wettkampfVO.paarung6ErgebnisHeim = p6[0].key;
			wettkampfVO.paarung6ErgebnisGast = p6[1].key;
		}else{
			wettkampfVO.paarung6ErgebnisHeim = 0;
			wettkampfVO.paarung6ErgebnisGast = 0;
		}
		
		wettkampfVO.paarung1 = mEdtPaarung1.getText().toString();
		wettkampfVO.paarung2 = mEdtPaarung2.getText().toString();
		wettkampfVO.paarung3 = mEdtPaarung3.getText().toString();
		wettkampfVO.paarung4 = mEdtPaarung4.getText().toString();
		wettkampfVO.paarung5 = mEdtPaarung5.getText().toString();
		wettkampfVO.paarung6 = mEdtPaarung6.getText().toString();
		
		return true;
	}

	private void loadPreference(){
		SharedPreferences mySharedPreferences = getPrivateSharedPreferences();
		int klassePos = mySharedPreferences.getInt(PREFERENCE_KEY_INDEX_SPIELGRUPPE, 0);
		int mannschaftHeimPos = mySharedPreferences.getInt(PREFERENCE_KEY_INDEX_MANNSCHAFT_HEIM, 0);
		int mannschaftGastPos = mySharedPreferences.getInt(PREFERENCE_KEY_INDEX_MANNSCHAFT_GAST, 0);
		long wettkampfSpielNr = mySharedPreferences.getLong(PREFERENCE_KEY_INDEX_WETTKAMPF_SPIELNR, 0);
		mSelectedKlasseItemPosition = klassePos;
		mSelectedMannschaftHeimItemPosition = mannschaftHeimPos;
		mSelectedMannschaftGastItemPosition = mannschaftGastPos;
		mWettkampfSpielNr = wettkampfSpielNr;
	}
	
	private SharedPreferences getPrivateSharedPreferences(){
		return getSharedPreferences("KegelVerwaltungPrefs", Activity.MODE_PRIVATE);
	}
	
	private void savePreference() {
		KegelverwaltungPreference.getInstance(this).saveIntState(
				PREFERENCE_KEY_INDEX_SPIELGRUPPE, mSelectedKlasseItemPosition).saveIntState(
						PREFERENCE_KEY_INDEX_MANNSCHAFT_HEIM, mSelectedMannschaftHeimItemPosition).saveIntState(
								PREFERENCE_KEY_INDEX_MANNSCHAFT_GAST, mSelectedMannschaftGastItemPosition).saveLongState(
										PREFERENCE_KEY_INDEX_WETTKAMPF_SPIELNR, mWettkampfSpielNr);
		
	}
	
	private void wettkampfEMail() {
		sendMessage();
	}
	
	private void wettkampfEMailMitAnhang() {
		sendPictureMessage();
	}

	private void wettkampfPDF() {
		generatePDF();
	}
	
	private void sendPictureMessage() {
        try {
            Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
            
            String aEmailList[] = { "guenter.platzerworld@gmail.com" };  
            String aEmailCCList[] = { "guenter_platzer@web.de"};  
            //String aEmailBCCList[] = { "guenter.platzerworld@gmail.com" };  
              
            emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL, aEmailList);  
            emailIntent.putExtra(android.content.Intent.EXTRA_CC, aEmailCCList);  
            //emailIntent.putExtra(android.content.Intent.EXTRA_BCC, aEmailBCCList);  
            
            emailIntent.setType("image/jpeg");
            File root = Environment.getExternalStorageDirectory();
		    if (root.canWrite()){
		    	File dir = new File(root, "kegeln");
		    	dir.mkdir();
		    	File fileUpload = new File(dir, "kegelverwaltung.db");
		    	emailIntent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(fileUpload));
		    }

            startActivity(Intent.createChooser(emailIntent, "Sende Anhang:"));
        } catch (Exception e) {
            Toast.makeText(this, "No handler", Toast.LENGTH_LONG).show();
        }
    }
	
	private void sendMessage() {
        try {
            Intent emailIntent = new Intent(android.content.Intent.ACTION_SEND);
            
            String aEmailList[] = { "guenter.platzerworld@gmail.com" };  
            String aEmailCCList[] = { "guenter_platzer@web.de"};  
            //String aEmailBCCList[] = { "guenter.platzerworld@gmail.com" };  
              
            emailIntent.putExtra(android.content.Intent.EXTRA_EMAIL, aEmailList);  
            emailIntent.putExtra(android.content.Intent.EXTRA_CC, aEmailCCList);  
            //emailIntent.putExtra(android.content.Intent.EXTRA_BCC, aEmailBCCList);  
            
            
            
            emailIntent.setType("plain/text");  
            emailIntent.putExtra(android.content.Intent.EXTRA_SUBJECT, "Ergebnis SpielNr: " +mWettkampfSpielNr);  
            StringBuffer bf = new StringBuffer("Endergebnis Spielnummer: " +mWettkampfSpielNr);
            bf.append("\n").append(mSelectedMannschaftHeimKeyValueVO.value).append(" - ").append(mSelectedMannschaftGastKeyValueVO.value)
            .append("\n").append(wettkampfVO.gesamtErgebnis);
            
            emailIntent.putExtra(android.content.Intent.EXTRA_TEXT, bf.toString());
            
            //emailIntent.setType("image/jpeg");
            //File downloadedPic = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS), "q.jpeg");
            //emailIntent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(downloadedPic));
            
            

            startActivity(Intent.createChooser(emailIntent, "Send picture using:"));
        } catch (Exception e) {
            Toast.makeText(this, "No handler", Toast.LENGTH_LONG).show();
        }
    }
	
	private void generatePDF(){
		if(null != wettkampfVO){
			String pdfcontent = generateHelloWorldPDF();
	        outputToScreen(pdfcontent);
	        outputToFile("wettkampfergebnis.pdf",pdfcontent,"ISO-8859-1");
		}
		
	}
	
	private String generateHelloWorldPDF() {
        
		PDFWriter mPDFWriter = new PDFWriter(PaperSize.FOLIO_WIDTH, PaperSize.FOLIO_HEIGHT);
        
		mPDFWriter.addText(200, 905, 18, "Ergebnis zum Spiel " +wettkampfVO.spielNr);
		mPDFWriter.addLine(200, 900, 370, 900);
       
		mPDFWriter.addText(130, 870, 14, "Spieltag: " +wettkampfVO.spielZeit);
		
        StringBuffer bf = null;
        bf = new StringBuffer();
        bf.append(mSelectedMannschaftHeimKeyValueVO.value).append("     ").append(wettkampfVO.gesamtErgebnis)
        .append("     ").append(mSelectedMannschaftGastKeyValueVO);
		
		mPDFWriter.addText(130, 850, 14, bf.toString());
		
		mPDFWriter.addText(50, 800, 14, "DG");
		mPDFWriter.addText(100, 800, 14, "Spieler Heim");
		mPDFWriter.addText(270, 800, 14, "Ergebnis");
		mPDFWriter.addText(340, 800, 14, "Ergebnis");
		mPDFWriter.addText(415, 800, 14, "Spieler Gast");
		
		ErgebnisVO[] p1 = null;
		mSpielerSpeicher = new SpielerSpeicher(this);
		SpielerVO heimSpieler = null;
		SpielerVO gastSpieler = null;
		
		if(paarungen.containsKey(new Integer(1))){
			p1 = paarungen.get(new Integer(1));
			heimSpieler = mSpielerSpeicher.ladeSpielerVO(p1[0].spielerId);
			gastSpieler = mSpielerSpeicher.ladeSpielerVO(p1[1].spielerId);
			
			if(null != heimSpieler && null != gastSpieler){
				mPDFWriter.addText(50, 780, 14, "1");
				mPDFWriter.addText(100, 780, 14, heimSpieler.name);
				mPDFWriter.addText(270, 780, 14, String.valueOf(p1[0].gesamtergebnis));
				mPDFWriter.addText(340, 780, 14, String.valueOf(p1[1].gesamtergebnis));
				mPDFWriter.addText(415, 780, 14, gastSpieler.name);
			}
		}
		
		if(paarungen.containsKey(new Integer(2))){
			p1 = paarungen.get(new Integer(2));
			heimSpieler = mSpielerSpeicher.ladeSpielerVO(p1[0].spielerId);
			gastSpieler = mSpielerSpeicher.ladeSpielerVO(p1[1].spielerId);
			
			if(null != heimSpieler && null != gastSpieler){
				mPDFWriter.addText(50, 760, 14, "2");
				mPDFWriter.addText(100, 760, 14, heimSpieler.name);
				mPDFWriter.addText(270, 760, 14, String.valueOf(p1[0].gesamtergebnis));
				mPDFWriter.addText(340, 760, 14, String.valueOf(p1[1].gesamtergebnis));
				mPDFWriter.addText(415, 760, 14, gastSpieler.name);
			}	
		}
		
		if(paarungen.containsKey(new Integer(3))){
			p1 = paarungen.get(new Integer(3));
			heimSpieler = mSpielerSpeicher.ladeSpielerVO(p1[0].spielerId);
			gastSpieler = mSpielerSpeicher.ladeSpielerVO(p1[1].spielerId);
			
			if(null != heimSpieler && null != gastSpieler){
				mPDFWriter.addText(50, 740, 14, "3");
				mPDFWriter.addText(100, 740, 14, heimSpieler.name);
				mPDFWriter.addText(270, 740, 14, String.valueOf(p1[0].gesamtergebnis));
				mPDFWriter.addText(340, 740, 14, String.valueOf(p1[1].gesamtergebnis));
				mPDFWriter.addText(415, 740, 14, gastSpieler.name);
			}	
		}
		
		if(paarungen.containsKey(new Integer(4))){
			p1 = paarungen.get(new Integer(4));
			heimSpieler = mSpielerSpeicher.ladeSpielerVO(p1[0].spielerId);
			gastSpieler = mSpielerSpeicher.ladeSpielerVO(p1[1].spielerId);
			
			if(null != heimSpieler && null != gastSpieler){
				mPDFWriter.addText(50, 720, 14, "4");
				mPDFWriter.addText(100, 720, 14, heimSpieler.name);
				mPDFWriter.addText(270, 720, 14, String.valueOf(p1[0].gesamtergebnis));
				mPDFWriter.addText(340, 720, 14, String.valueOf(p1[1].gesamtergebnis));
				mPDFWriter.addText(415, 720, 14, gastSpieler.name);
			}	
		}
		
		if(paarungen.containsKey(new Integer(5))){
			p1 = paarungen.get(new Integer(5));
			heimSpieler = mSpielerSpeicher.ladeSpielerVO(p1[0].spielerId);
			gastSpieler = mSpielerSpeicher.ladeSpielerVO(p1[1].spielerId);
			
			if(null != heimSpieler && null != gastSpieler){
				mPDFWriter.addText(50, 700, 14, "5");
				mPDFWriter.addText(100, 700, 14, heimSpieler.name);
				mPDFWriter.addText(270, 700, 14, String.valueOf(p1[0].gesamtergebnis));
				mPDFWriter.addText(340, 700, 14, String.valueOf(p1[1].gesamtergebnis));
				mPDFWriter.addText(415, 700, 14, gastSpieler.name);
			}	
		}
		
		if(paarungen.containsKey(new Integer(6))){
			p1 = paarungen.get(new Integer(6));
			heimSpieler = mSpielerSpeicher.ladeSpielerVO(p1[0].spielerId);
			gastSpieler = mSpielerSpeicher.ladeSpielerVO(p1[1].spielerId);
			
			if(null != heimSpieler && null != gastSpieler){
				mPDFWriter.addText(50, 680, 14, "6");
				mPDFWriter.addText(100, 680, 14, heimSpieler.name);
				mPDFWriter.addText(270, 680, 14, String.valueOf(p1[0].gesamtergebnis));
				mPDFWriter.addText(340, 680, 14, String.valueOf(p1[1].gesamtergebnis));
				mPDFWriter.addText(415, 680, 14, gastSpieler.name);
			}	
		}
		
        String s = mPDFWriter.asString();
        
        return s;
	}
	
	private void outputToScreen(String pdfContent) {
        Toast.makeText(this, pdfContent, Toast.LENGTH_SHORT).show();
	}
	
	private void outputToFile(String fileName, String pdfContent, String encoding) {
		
        try {
        	File filePDF = null;
        	File root = Environment.getExternalStorageDirectory();
    	    if (root.canWrite()){
    	    	File dir = new File(root, "kegeln");
    	    	dir.mkdir();
    	    	filePDF = new File(dir, fileName);
    	    	filePDF.createNewFile();
    	    }
        	
            try {
            	FileOutputStream pdfFile = new FileOutputStream(filePDF);
            	pdfFile.write(pdfContent.getBytes(encoding));
                pdfFile.close();
            } catch(FileNotFoundException e) {
            	//
            }
        } catch(IOException e) {
        }
	}
	
	

}
